// 版权所有2021 Go作者。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package noder

import (
	"go/constant"

	"cmd/compile/internal/base"
	"cmd/compile/internal/ir"
	"cmd/compile/internal/typecheck"
	"cmd/compile/internal/types"
	"cmd/internal/src"
)

// 用于构造类型化IR节点的帮助程序。
// None
// TODO（mdempsky）：进入他们自己的包，这样他们就可以轻松
// 被iimport和前端优化重用。

type ImplicitNode interface {
	ir.Node
	SetImplicit(x bool)
}

// Implicit在将其标记为Implicit后返回n。
func Implicit(n ImplicitNode) ImplicitNode {
	n.SetImplicit(true)
	return n
}

// typed将其类型设置为typ后返回n。
func typed(typ *types.Type, n ir.Node) ir.Node {
	n.SetType(typ)
	n.SetTypecheck(1)
	return n
}

// 价值观

func Const(pos src.XPos, typ *types.Type, val constant.Value) ir.Node {
	return typed(typ, ir.NewBasicLit(pos, val))
}

func Nil(pos src.XPos, typ *types.Type) ir.Node {
	return typed(typ, ir.NewNilExpr(pos))
}

// 表达

func Addr(pos src.XPos, x ir.Node) *ir.AddrExpr {
	n := typecheck.NodAddrAt(pos, x)
	switch x.Op() {
	case ir.OARRAYLIT, ir.OMAPLIT, ir.OSLICELIT, ir.OSTRUCTLIT:
		n.SetOp(ir.OPTRLIT)
	}
	typed(types.NewPtr(x.Type()), n)
	return n
}

func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node {
	return typed(typ, ir.NewTypeAssertExpr(pos, x, nil))
}

func Binary(pos src.XPos, op ir.Op, typ *types.Type, x, y ir.Node) ir.Node {
	switch op {
	case ir.OANDAND, ir.OOROR:
		return typed(x.Type(), ir.NewLogicalExpr(pos, op, x, y))
	case ir.OADD:
		n := ir.NewBinaryExpr(pos, op, x, y)
		if x.Type().HasTParam() || y.Type().HasTParam() {
			// 延迟transformAdd（），如果任一参数具有类型param，
			// 因为它需要知道确切的类型来决定
			// 将OADD转换为OADDSR。
			n.SetType(typ)
			n.SetTypecheck(3)
			return n
		}
		typed(typ, n)
		return transformAdd(n)
	default:
		return typed(x.Type(), ir.NewBinaryExpr(pos, op, x, y))
	}
}

func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool) ir.Node {
	n := ir.NewCallExpr(pos, ir.OCALL, fun, args)
	n.IsDDD = dots
	// n、 如果调用失败，则在g.stmt（）中的Use将更改为ir.CallUseStmt
	// 只是一个语句（忽略任何返回值）。
	n.Use = ir.CallUseExpr

	if fun.Op() == ir.OTYPE {
		// 实际上是类型转换，而不是函数调用。
		if fun.Type().HasTParam() || args[0].Type().HasTParam() {
			// 对于类型参数，在我们真正知道之前不要进行类型检查
			// 类型。
			return typed(typ, n)
		}
		typed(typ, n)
		return transformConvCall(n)
	}

	if fun, ok := fun.(*ir.Name); ok && fun.BuiltinOp != 0 {
		// 对于内置操作，我们目前仍然使用旧的
		// typechecker将调用转换为更具体的表达式
		// 并可能使用更具体的行动。然而，对于许多人来说
		// ops，如果有任何参数出现错误，我们将延迟执行旧的typechecker
		// 类型params，原因有多种：
		// None
		// OMAKE：在知道arg类型之前，很难选择特定的操作OMAKESLICE等
		// OREAL/OIMAG:在arg type知道之前无法确定float32/float64类型
		// OLEN/OCAP：如果arg不是明显的片/数组，旧的typechecker会抱怨。
		// OAPPEND：如果arg不是明显的切片，旧的typechecker会抱怨，等等。
		// None
		// 我们最终将突破转换功能
		// 需要内置的，并在这里调用或在制版过程中调用，如
		// 适当的
		switch fun.BuiltinOp {
		case ir.OMAKE, ir.OREAL, ir.OIMAG, ir.OLEN, ir.OCAP, ir.OAPPEND:
			hasTParam := false
			for _, arg := range args {
				if arg.Type().HasTParam() {
					hasTParam = true
					break
				}
			}
			if hasTParam {
				return typed(typ, n)
			}
		}

		typed(typ, n)
		return transformBuiltin(n)
	}

	// 添加信息，现在我们知道实际上正在调用fun。
	switch fun := fun.(type) {
	case *ir.ClosureExpr:
		fun.Func.SetClosureCalled(true)
	case *ir.SelectorExpr:
		if fun.Op() == ir.OCALLPART {
			op := ir.ODOTMETH
			if fun.X.Type().IsInterface() {
				op = ir.ODOTINTER
			}
			fun.SetOp(op)
			// 将类型设置为包含接收器，因为这就是
			// 编译器的后面部分
			fun.SetType(fun.Selection.Type)
		}
	}

	if fun.Type().HasTParam() {
		// 如果fun参数是或有一个type param，不要做任何额外的操作
		// 转换，因为我们可能还没有所需的属性
		// （例如，返回值的数量等）。类型param可能是
		// 由结构约束描述，该约束要求它是
		// 某些函数类型，等等，但我们不想对此进行分析。
		return typed(typ, n)
	}

	if fun.Op() == ir.OXDOT {
		if !fun.(*ir.SelectorExpr).X.Type().HasTParam() {
			base.FatalfAt(pos, "Expecting type param receiver in %v", fun)
		}
		// 对于在泛型函数中调用的方法，不要做任何额外的操作
		// 转变。我们将在稍后创建
		// 实例化函数并具有正确的接收器类型。
		typed(typ, n)
		return n
	}
	if fun.Op() != ir.OFUNCINST {
		// 如果没有类型参数，则执行常规调用转换。这
		// 将OCALL转换为OCALLFUNC。
		typed(typ, n)
		transformCall(n)
		return n
	}

	// 将op保留为OCALL，这表示调用仍然需要进行类型检查。
	typed(typ, n)
	return n
}

func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) ir.Node {
	n := ir.NewBinaryExpr(pos, op, x, y)
	if x.Type().HasTParam() || y.Type().HasTParam() {
		// 延迟transformCompare（），如果任一参数具有类型param，则为
		// 它需要知道确切的类型来决定任何需要的转换。
		n.SetType(typ)
		n.SetTypecheck(3)
		return n
	}
	typed(typ, n)
	transformCompare(n)
	return n
}

func Deref(pos src.XPos, typ *types.Type, x ir.Node) *ir.StarExpr {
	n := ir.NewStarExpr(pos, x)
	typed(typ, n)
	return n
}

func DotField(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr {
	op, typ := ir.ODOT, x.Type()
	if typ.IsPtr() {
		op, typ = ir.ODOTPTR, typ.Elem()
	}
	if !typ.IsStruct() {
		base.FatalfAt(pos, "DotField of non-struct: %L", x)
	}

	// TODO（mdempsky）：这是后端的责任。
	types.CalcSize(typ)

	field := typ.Field(index)
	return dot(pos, field.Type, op, x, field)
}

func DotMethod(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr {
	method := method(x.Type(), index)

	// 方法值。
	typ := typecheck.NewMethodType(method.Type, nil)
	return dot(pos, typ, ir.OCALLPART, x, method)
}

// MethodExpr将带有指示索引的OMETHEXPR节点返回到方法中
// 典型的。接收器类型是从recv设置的，如果
// 方法是通过嵌入字段访问的。类似地
// ir.SelectorExpr是recv，在通过
// 嵌入字段。
func MethodExpr(pos src.XPos, recv ir.Node, embed *types.Type, index int) *ir.SelectorExpr {
	method := method(embed, index)
	typ := typecheck.NewMethodType(method.Type, recv.Type())
	// 当T
	// 与m声明的接收器类型不同。我们
	// 通常在写的时候生成这些包装
	// 运行时类型描述符，这总是针对
	// 在包作用域中声明的类型。然而，我们需要
	// 确保为匿名用户生成包装器
	// 接收器类型也一样。
	if recv.Sym() == nil {
		typecheck.NeedRuntimeType(recv.Type())
	}
	return dot(pos, typ, ir.OMETHEXPR, recv, method)
}

func dot(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node, selection *types.Field) *ir.SelectorExpr {
	n := ir.NewSelectorExpr(pos, op, x, selection.Sym)
	n.Selection = selection
	typed(typ, n)
	return n
}

// TODO（mdempsky）：移动到包类型。
func method(typ *types.Type, index int) *types.Field {
	if typ.IsInterface() {
		return typ.AllMethods().Index(index)
	}
	return types.ReceiverBaseType(typ).Methods().Index(index)
}

func Index(pos src.XPos, typ *types.Type, x, index ir.Node) ir.Node {
	n := ir.NewIndexExpr(pos, x, index)
	if x.Type().HasTParam() {
		// transformIndex需要知道确切的类型
		n.SetType(typ)
		n.SetTypecheck(3)
		return n
	}
	typed(typ, n)
	// transformIndex将修改OINDEXMAP的n.Type（）。
	transformIndex(n)
	return n
}

func Slice(pos src.XPos, typ *types.Type, x, low, high, max ir.Node) ir.Node {
	op := ir.OSLICE
	if max != nil {
		op = ir.OSLICE3
	}
	n := ir.NewSliceExpr(pos, op, x, low, high, max)
	if x.Type().HasTParam() {
		// transformSlice需要知道x.Type（）是字符串还是数组或切片。
		n.SetType(typ)
		n.SetTypecheck(3)
		return n
	}
	typed(typ, n)
	transformSlice(n)
	return n
}

func Unary(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node) ir.Node {
	switch op {
	case ir.OADDR:
		return Addr(pos, x)
	case ir.ODEREF:
		return Deref(pos, typ, x)
	}

	if op == ir.ORECV {
		if typ.IsFuncArgStruct() && typ.NumFields() == 2 {
			// 删除第二个布尔类型（如果由type2提供），
			// 因为这对编译器的其余部分效果更好
			// （稍后会将其添加回）。
			assert(typ.Field(1).Type.Kind() == types.TBOOL)
			typ = typ.Field(0).Type
		}
	}
	return typed(typ, ir.NewUnaryExpr(pos, op, x))
}

// 声明

var one = constant.MakeInt64(1)

func IncDec(pos src.XPos, op ir.Op, x ir.Node) *ir.AssignOpStmt {
	assert(x.Type() != nil)
	return ir.NewAssignOpStmt(pos, op, x, typecheck.DefaultLit(ir.NewBasicLit(pos, one), x.Type()))
}
